Replace the `(CellRef, Option<u64>)` and `(CellId, Option<u64>, TaskId)`
tuples used for cell-edge tracking with a `CellDependency` enum:

    enum CellDependency {
        All(CellRef),
        Hash(CellRef, u64),
    }

`Option<u64>` previously cost a full 16 B (8 B discriminant + 8 B value,
aligned). With an explicit enum the layout algorithm reuses the niche on
`ValueTypeId` (`NonZero<u16>`) inside `CellRef.cell.type_id` for the
variant tag, dropping the element from 32 B to 24 B. That in turn shrinks
`LazyField` from 56 B to 48 B.

Also adds `CellDependency::into_parts()` and uses it in
`iter_cell_dependents` / `iter_cell_dependencies` hot loops to avoid
checking the enum discriminant twice via back-to-back
`cell_ref()` + `key()` calls.

Replace `TaskStorage::lazy: Vec<LazyField>` with a custom 16 B `TinyVec`
(u8 len + u8 cap, the schema's max field count is well under 255).
Drops `size_of::<TaskStorage>()` from 136 B to 128 B.

Included micro-benchmarks show `TinyVec` push is 11-32% faster than `Vec`
across realistic sizes and iter is neutral.

The `TinyVec` type:

* Carries a `const MAX: u8` generic parameter that strictly caps push count
  and tightens the growth schedule (doubles until it would exceed MAX, then
  caps exactly at MAX). The schema macro emits `TinyVec<LazyField, N>` where
  `N` is the exact lazy-field count, so the cap matches the actual schema
  size (e.g. with 24 variants we end at cap=24 instead of cap=32, saving a
  few slots per fully-populated task). A compile-time static assert rejects
  `MAX = 0` at monomorphization.
* Tightens visibility: `new`, `capacity`, `as_slice`, `as_mut_slice`,
  `reserve` are private; `len` / `is_empty` stay pub as a clippy-preferred
  pair.
* Delegates `retain_mut` to `Vec::retain_mut` via a `Vec::from_raw_parts`
  round-trip — `retain_mut` is cold relative to push so the round-trip cost
  is irrelevant, and this drops ~7 unsafe blocks with a panic partial-shift
  guard.
* Delegates owned `IntoIter` to `std::vec::IntoIter` via the same Vec
  round-trip, dropping ~50 lines of unsafe.
* Drops `Extend` and `FromIterator` trait impls; the only caller path uses
  an inherent `extend_exact` which requires an `ExactSizeIterator` and
  reserves exactly once.
* Drops `iter`, `iter_mut`, `last_mut`, `Index`, `IndexMut` — all reachable
  through `Deref<Target = [T]>`. `for x in &tv` / `for x in &mut tv` still
  need `IntoIterator` impls for refs because the `for`-loop desugar doesn't
  apply `Deref` coercion across the reference boundary.

Net unsafe count in `TinyVec` is 5 in the hot path plus 1 in `retain_mut`
and 1 in `IntoIter` — each upholding a single local invariant or just
round-tripping through Vec.

Each schema field's `I` (inline capacity) was previously fixed at 1. With
`SmallVec`'s `union` feature on, the heap variant occupies 16 bytes
(`NonNull<T> + usize`), so the SmallVec body is always `max(16, N * sizeof(T))`
aligned to `max(align(T), 8)`. Net: growing `N` is free until `N * sizeof(T)`
exceeds 16, after which each step adds `align_up(sizeof(T), 8)` bytes.

Two opportunities follow:

* For lazy fields, the `LazyField` enum already pays a 40-byte payload
  budget (the largest variants — `cell_data`, `cell_data_hash`,
  `AutoSet<CellDependency>`, `CounterMap<CollectibleRef, i32>` — saturate
  it at I=1). Smaller-element fields sat at 32 B with 8 B of unused
  padding. Bumping them to fill 40 B is zero-cost: TaskStorage and
  LazyField sizes don't change.

* For inline fields on TaskStorage, raising `I` is free up to the SmallVec
  16-byte body limit (e.g. `AutoSet<TaskId>` to I=4, `CounterMap<TaskId,
  u32>` to I=2).

To allow per-field tuning, parameterize:

* `CounterMap` over `const I: usize`, propagating to its `AutoMap` inner.
* The `AutoSet` / `AutoMap` schema aliases drop their hardcoded `1`; each
  field declares its own `I`.

Per-field choices:

* `output_dependent` (inline) `AutoSet<TaskId>` → 4 (32 B)
* `upper` (inline) `CounterMap<TaskId, u32>` → 2 (32 B)
* `children`, `output_dependencies`, `outdated_output_dependencies`
  `AutoSet<TaskId>` → 6 (40 B)
* `collectibles_dependencies`, `outdated_collectibles_dependencies`
  `AutoSet<CollectiblesRef>` → 3 (40 B)
* `collectibles_dependents` `AutoSet<(TraitTypeId, TaskId)>` → 3 (40 B)
* `followers`, `aggregated_dirty_containers`,
  `aggregated_current_session_clean_containers`
  `CounterMap<TaskId, _>` → 3 (40 B)
* `cell_type_max_index` `AutoMap<ValueTypeId, u32>` → 3 (40 B)

Variants already at 40 B (cell_data, cell_data_hash, AutoSet<CellDependency>,
CounterMap<CollectibleRef, i32>) stay at I=1. `in_progress_cells` stays at
I=1 to avoid overflowing LazyField under the `hanging_detection` feature
(which inflates `Event` from 8 B to 16 B).

`TaskStorage` stays at 128 B, `LazyField` at 48 B; only inline capacities
change.